{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. 变分自编码器 (Variational AutoEncoder)\n",
    "(1) 在自编码器中，无法生成新的图像，只能实现输入图像的重构，因为隐向量只能通过编码器得到\n",
    "\n",
    "(2) 为了生成新的图像，首先需要得到隐向量，才能解码为正常的图像，变分自编码器解决了该问题，解决的思路：\n",
    "1. 可以通过随机方法生成与编码器输出的隐向量接近的向量\n",
    "2. 重构出的图像与原图像要相似\n",
    "\n",
    "(3) 变分自编码器VAE成功的解决了该问题，方法如下：\n",
    "1. 使用重参数方法，使编码器得到两个向量，一个表示均值E，一个表示标准差D，然后使用标准正态分布乘标准差加均值得到分布 $N(E,D^2)$，然后使该分布与标准的正态分布 $N(0,1)$尽可能接近\n",
    "2. 使重构的图像与原图尽可能相似\n",
    "\n",
    "(4) KL divergence(KL散度)用来衡量两个分布的相似程度，**值越小**表示两种概率分布越**接近**\n",
    "\n",
    "离散的概率分布：\n",
    "$$D_{KL}(P\\|Q)=\\sum_iP(i)log\\frac{P(i)}{Q(i)}$$\n",
    "连续的概率分布：\n",
    "$$D_{KL}(P\\|Q)=\\int_{-\\infty}^{+\\infty}p(x)log\\frac{p(x)}{q(x)}dx$$\n",
    "\n",
    "\n",
    "<img src='./image/VAE.jpg' height='80%' width='80%'>\n",
    "\n",
    "<center>变分自编码器</center>\n",
    "该图显示了变分自编码器的整体结构，图片出自CS231n的课件，注意这里的**解码器部分仍使用了重参数的方法**，在有些地方没有使用重参数，而是直接使用全连接层来重构图像"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1 数据预处理"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import torch\n",
    "import numpy as np\n",
    "from torch import nn, optim\n",
    "import torch.nn.functional as F\n",
    "import matplotlib.pyplot as plt\n",
    "from torch.autograd import Variable\n",
    "from torch.utils.data import DataLoader\n",
    "from torchvision import datasets, transforms\n",
    "from torchvision.utils import save_image\n",
    "\n",
    "use_cuda = torch.cuda.is_available()                    # gpu可用\n",
    "device = torch.device('cuda' if use_cuda else 'cpu')    # 优先使用gpu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 设置超参数(Hyperparameters)\n",
    "batch_size = 64\n",
    "learning_rate = 1e-3\n",
    "num_epochs = 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1.读取数据及预处理\n",
    "# Compose将各种预处理操作组合，ToTensor将图片处理为tensor，\n",
    "# Normalize(mean, variance)正则化\n",
    "data_tf = transforms.Compose([transforms.ToTensor()])     # 数据变为tensor，范围[0,1]\n",
    "   \n",
    "# 下载MNIST手写数字训练集\n",
    "train_dataset = datasets.MNIST(root='./data/MNIST', train=True, transform=data_tf, download=False)\n",
    "test_dataset = datasets.MNIST(root='./data/MNIST', train=False, transform=data_tf)\n",
    "# 创建数据迭代器便于训练模型\n",
    "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=4)#, pin_memory=True)\n",
    "test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.训练数据的维度:\n",
      "torch.Size([60000, 28, 28])\n",
      "torch.Size([60000])\n",
      "2.测试数据的维度:\n",
      "torch.Size([10000, 28, 28])\n",
      "torch.Size([10000])\n"
     ]
    }
   ],
   "source": [
    "print('1.训练数据的维度:')\n",
    "print(train_dataset.train_data.shape)\n",
    "print(train_dataset.train_labels.shape)\n",
    "print('2.测试数据的维度:')\n",
    "print(test_dataset.test_data.shape)\n",
    "print(test_dataset.test_labels.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2 创建模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# VAE model\n",
    "class VAE(nn.Module):\n",
    "    def __init__(self, image_size=784, h_dim=400, z_dim=40):\n",
    "        super(VAE, self).__init__()\n",
    "        self.fc1 = nn.Linear(image_size, h_dim)\n",
    "        self.fc2 = nn.Linear(h_dim, z_dim) # 均值 向量\n",
    "        self.fc3 = nn.Linear(h_dim, z_dim) # 保准方差 向量\n",
    "        self.fc4 = nn.Linear(z_dim, h_dim)\n",
    "        self.fc5 = nn.Linear(h_dim, image_size)\n",
    "        \n",
    "    # 编码过程\n",
    "    def encode(self, x):\n",
    "        x_flatten = x.view(x.shape[0], -1)\n",
    "        h = F.relu(self.fc1(x_flatten))\n",
    "        return self.fc2(h), self.fc3(h)\n",
    "    \n",
    "    # 随机生成隐含向量\n",
    "    def reparameterize(self, mu, log_var):\n",
    "        std = torch.exp(log_var/2)\n",
    "        eps = torch.randn_like(std)\n",
    "        return mu + eps * std\n",
    "\n",
    "    # 解码过程\n",
    "    def decode(self, z):\n",
    "        h = F.relu(self.fc4(z))\n",
    "        return torch.sigmoid(self.fc5(h)).view(-1,1,28,28)\n",
    "    \n",
    "    # 整个前向传播过程：编码-》解码\n",
    "    def forward(self, x):\n",
    "        mu, log_var = self.encode(x)\n",
    "        z = self.reparameterize(mu, log_var)\n",
    "        x_reconst = self.decode(z)\n",
    "        return x_reconst, mu, log_var"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# cs231n上的vae模型\n",
    "class VAE_231n(nn.Module):\n",
    "    def __init__(self, image_size=784, h2_dim=400, z_dim=40, h3_dim=400):\n",
    "        super().__init__()\n",
    "        self.fc1  = nn.Linear(image_size, h2_dim)             # (N, h2_dim)\n",
    "        self.fc21 = nn.Linear(h2_dim, z_dim)                  # 编码器 均值向量   (N, z_dim)    \n",
    "        self.fc22 = nn.Linear(h2_dim, z_dim)                  # 编码器 方差向量   (N, z_dim)  \n",
    "        self.fc31 = nn.Linear(z_dim, h3_dim)                  # 解码器 均值向量   (N, h3_dim) \n",
    "        self.fc32 = nn.Linear(z_dim, h3_dim)                  # 解码器 方差向量   (N, h3_dim)\n",
    "        self.fc4  = nn.Linear(h3_dim, image_size)             # (N, image_size)\n",
    "        \n",
    "    # 编码器 encoder\n",
    "    def encode(self, x):                                       # input (N,1,28,28)\n",
    "        x_flatten = x.view(x.shape[0], -1)\n",
    "        h = F.relu(self.fc1(x_flatten))                        # (N, h2_dim)\n",
    "        return self.fc21(h), self.fc22(h)                      # mean logvar\n",
    "    \n",
    "    # 重参数，随机生成隐向量\n",
    "    def reparameterize(self, mu, logvar):   \n",
    "        std = torch.exp(logvar/2)                              # 计算标准差\n",
    "        eps = torch.randn_like(std) #.to(device)               # 生成std维度大小的标准正态\n",
    "        return eps * std + mu                                  # 生成分布 N(mu, std^2)\n",
    "        \n",
    "    # 解码器 decoder (与其他vae的差别)\n",
    "    def decode(self, x):                                       # input (N, z_dim)\n",
    "#         print(x.shape)\n",
    "        mu, logvar = self.fc31(x), self.fc32(x)                # mean logvar\n",
    "        h3 = F.relu(self.reparameterize(mu, logvar))           # (N, h3_dim)\n",
    "        x_hat = torch.sigmoid(self.fc4(h3))                    # (N, image_size) 数据在(0,1)\n",
    "        return x_hat.view(-1, 1, 28, 28)                       # (N,1,28,28)\n",
    "        \n",
    "    # 前向传播\n",
    "    def forward(self, x):                                      # (N,1,28,28)\n",
    "        mu, logvar = self.encode(x)\n",
    "        z = self.reparameterize(mu, logvar)                    # 编码器输出进行重参数\n",
    "        x_hat = self.decode(z)                                \n",
    "        return x_hat, mu, logvar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.3 定义损失函数及优化方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义MSE损失与KL散度损失之和\n",
    "def loss_function(x_hat, x, mu, logvar):\n",
    "#     recon_loss = F.binary_cross_entropy(x_hat, x, reduction='sum')  # 输入和重构图像间的交叉熵\n",
    "    recon_loss = nn.MSELoss(reduction='sum')(x_hat, x)                # 使用均方误差损失 \n",
    "#     recon_loss = nn.BCELoss(reduction='sum')(x_hat, x)              # 使用二分类交叉熵损失\n",
    "    kl_div = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())\n",
    "    recon_loss.data.mul_(1)\n",
    "    kl_div.data.mul_(1)\n",
    "#     print('{:.2f} {:.2f}'.format(recon_loss.data.item(), kl_div.data.item()))\n",
    "#     print('---')\n",
    "    return (recon_loss + kl_div)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "vae = VAE_231n().to(device)\n",
    "optimizer = optim.Adam(vae.parameters(), lr=learning_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "------------Epoch:0-------------\n",
      "Iter:0     loss:193.6148\n",
      "Iter:500   loss:45.1755\n",
      "Iter:937   loss:39.9323\n",
      "------------Epoch:1-------------\n",
      "Iter:0     loss:40.7487\n",
      "Iter:500   loss:36.7622\n",
      "Iter:937   loss:36.1179\n",
      "------------Epoch:2-------------\n",
      "Iter:0     loss:36.2859\n",
      "Iter:500   loss:32.5699\n",
      "Iter:937   loss:35.8415\n",
      "------------Epoch:3-------------\n",
      "Iter:0     loss:31.9603\n",
      "Iter:500   loss:32.5190\n",
      "Iter:937   loss:31.8768\n",
      "------------Epoch:4-------------\n",
      "Iter:0     loss:32.5520\n",
      "Iter:500   loss:32.9713\n",
      "Iter:937   loss:31.7961\n",
      "------------Epoch:5-------------\n",
      "Iter:0     loss:33.2854\n",
      "Iter:500   loss:30.7956\n",
      "Iter:937   loss:34.9811\n",
      "------------Epoch:6-------------\n",
      "Iter:0     loss:31.4084\n",
      "Iter:500   loss:32.4500\n",
      "Iter:937   loss:31.2433\n",
      "Wall time: 1min 11s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\ProgramData\\Anaconda3\\lib\\site-packages\\torch\\serialization.py:241: UserWarning: Couldn't retrieve source code for container of type VAE_231n. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# 开始训练模型\n",
    "num_epochs = 7\n",
    "pltX, pltY = [], []\n",
    "epoch_end = len(train_loader) - 1\n",
    "for epoch in range(num_epochs):\n",
    "    print('------------Epoch:%d-------------' % epoch)\n",
    "    for iteration, data in enumerate(train_loader):\n",
    "        x, _ = data                                               # 读入图像数据，只是用x就行\n",
    "        x = x.to(device)                                          # 转换数据类型\n",
    "#         x = x.type(torch.cuda.FloatTensor)\n",
    "\n",
    "        x_hat, mu, logvar = vae(x)                                # (N,1,28, 28)\n",
    "        loss = loss_function(x_hat, x, mu, logvar) / x.shape[0]   # 计算L2损失，\n",
    "#         print(loss)\n",
    "        print_loss = loss.data.item()                             # tensor转换为一个数\n",
    "        \n",
    "        # 优化模型\n",
    "        optimizer.zero_grad()                                     # 梯度归零\n",
    "        loss.backward()                                           # 反向传播\n",
    "        optimizer.step()                                          # 更新参数\n",
    "        \n",
    "        if iteration % 500 == 0 or iteration == epoch_end:\n",
    "#             pltX.append(epoch)\n",
    "            pltY.append(print_loss)\n",
    "            print('Iter:{:<5} loss:{:.4f}'.format(iteration, loss.data))\n",
    "save_image(x_hat, './image/vae_sample.png')\n",
    "torch.save(vae, './model/vae.pth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x21333219898>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2130b7d2c88>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 绘制loss曲线\n",
    "import imageio        # 读取图像\n",
    "plt.title('loss function output curve')\n",
    "plt.plot(pltY)        # 每500个迭代记录一次loss\n",
    "plt.show()\n",
    "img = imageio.imread('./image/vae_sample.png')       # (H,W,C)\n",
    "plt.title('sample')\n",
    "plt.axis('off')\n",
    "plt.imshow(img)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mu: tensor([[-0.1474,  0.0063,  0.0019,  ...,  0.0054,  0.0713,  0.9816],\n",
      "        [-0.2309,  0.0994,  0.0018,  ...,  0.1392, -0.0508,  0.3633],\n",
      "        [-1.5578, -0.0451,  0.0044,  ...,  0.0421, -0.0291,  1.1494],\n",
      "        ...,\n",
      "        [ 1.4564,  0.0397, -0.1315,  ...,  0.0160,  0.0034, -0.7325],\n",
      "        [-1.0248,  0.0009, -0.0269,  ...,  0.0307, -0.0017, -0.1887],\n",
      "        [ 0.3709,  0.1519, -0.0338,  ...,  0.0192, -0.0513,  0.2925]],\n",
      "       device='cuda:0', grad_fn=<ThAddmmBackward>)\n",
      "logvar: tensor([[-2.6996, -0.0136,  0.0206,  ..., -0.0146, -0.0492, -1.3865],\n",
      "        [-3.2928,  0.0272, -0.0034,  ..., -0.0154, -0.0078, -2.2073],\n",
      "        [-2.7316,  0.0378,  0.0477,  ..., -0.0013,  0.0001, -1.2547],\n",
      "        ...,\n",
      "        [-2.8619,  0.0615,  0.0064,  ...,  0.0315, -0.0122, -2.1507],\n",
      "        [-2.7052,  0.0357,  0.0298,  ...,  0.0035,  0.0081, -1.6618],\n",
      "        [-2.9671,  0.0170,  0.0105,  ..., -0.0049,  0.0261, -1.7912]],\n",
      "       device='cuda:0', grad_fn=<ThAddmmBackward>)\n"
     ]
    }
   ],
   "source": [
    "# 测试编码器输出的均值和方差\n",
    "def test_encode(model, dataloader):\n",
    "    x, y = next(dataloader.__iter__())\n",
    "    x = x.to(device)\n",
    "    mu, logvar = model.encode(x)\n",
    "    print('mu:', mu)\n",
    "    print('logvar:', logvar)\n",
    "test_encode(vae, test_loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2130b8f24a8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 测试模型的性能\n",
    "def test_gen(model):\n",
    "    img_name = './image/vae_gen.jpg'\n",
    "    with torch.no_grad():\n",
    "        z = torch.randn(batch_size, 40).to(device)   # (batch_size, z_dim)\n",
    "        out = model.decode(z)           # (128,1,28,28)\n",
    "        save_image(out, img_name)\n",
    "    img = imageio.imread(img_name)\n",
    "    plt.title('VAE generates new image')\n",
    "    plt.axis('off')\n",
    "    plt.imshow(img)\n",
    "    plt.show()\n",
    "test_gen(vae)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 损失函数的值之间怎么权衡？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
